{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Simple Linear Regression"
      ],
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "Linear Regression is the simplest form of regression. The dependent variable is continuous; however, the relationship between the dependent variable and indepedent variables is assumed to be linear. \n",
        "\n",
        "# Equation: y = mx + b\n",
        "\n",
        "y: dependent variable (target)   \n",
        "x: independent variable (predictor)\n",
        "m: constant and slope or gradient   \n",
        "b: intercept\n",
        "\n\n",
        "1. There must be a linear relation between independent and dependent variables. \n",
        "2. There should not be any outliers present. \n",
        "3. No heteroscedasticity \n",
        "4. Sample observations should be independent. \n",
        "5. Error terms should be normally distributed with mean 0 and constant variance. \n",
        "6. Absence of multicollinearity and auto-correlation.\n",
        "\n\n\nClassification trees have dependent variables that are categorical or label and unordered. Example: Pass or Fail. Regression trees have dependent variables that are continuous values or ordered whole values. Example; Percentages. Regression means to predict the output value using training data. Classification means to group the output into a class. "
      ],
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 1: Data Preprocessing"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "# fix_yahoo_finance is used to fetch data \n",
        "import fix_yahoo_finance as yf\n",
        "yf.pdr_override()"
      ],
      "outputs": [],
      "execution_count": 1,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# input\n",
        "symbol = 'AMD'\n",
        "start = '2007-01-01'\n",
        "end = '2018-12-31'\n",
        "\n",
        "# Read data \n",
        "dataset = yf.download(symbol,start,end)\n",
        "\n",
        "# View Columns\n",
        "dataset.head()"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[*********************100%***********************]  1 of 1 downloaded\n"
          ]
        },
        {
          "output_type": "execute_result",
          "execution_count": 2,
          "data": {
            "text/plain": [
              "                 Open       High        Low      Close  Adj Close    Volume\n",
              "Date                                                                       \n",
              "2007-01-03  20.080000  20.400000  19.350000  19.520000  19.520000  28350300\n",
              "2007-01-04  19.660000  19.860001  19.320000  19.790001  19.790001  23652500\n",
              "2007-01-05  19.540001  19.910000  19.540001  19.709999  19.709999  15902400\n",
              "2007-01-08  19.709999  19.860001  19.370001  19.469999  19.469999  15814800\n",
              "2007-01-09  19.450001  19.709999  19.370001  19.650000  19.650000  14494200"
            ],
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Open</th>\n",
              "      <th>High</th>\n",
              "      <th>Low</th>\n",
              "      <th>Close</th>\n",
              "      <th>Adj Close</th>\n",
              "      <th>Volume</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Date</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>2007-01-03</th>\n",
              "      <td>20.080000</td>\n",
              "      <td>20.400000</td>\n",
              "      <td>19.350000</td>\n",
              "      <td>19.520000</td>\n",
              "      <td>19.520000</td>\n",
              "      <td>28350300</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2007-01-04</th>\n",
              "      <td>19.660000</td>\n",
              "      <td>19.860001</td>\n",
              "      <td>19.320000</td>\n",
              "      <td>19.790001</td>\n",
              "      <td>19.790001</td>\n",
              "      <td>23652500</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2007-01-05</th>\n",
              "      <td>19.540001</td>\n",
              "      <td>19.910000</td>\n",
              "      <td>19.540001</td>\n",
              "      <td>19.709999</td>\n",
              "      <td>19.709999</td>\n",
              "      <td>15902400</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2007-01-08</th>\n",
              "      <td>19.709999</td>\n",
              "      <td>19.860001</td>\n",
              "      <td>19.370001</td>\n",
              "      <td>19.469999</td>\n",
              "      <td>19.469999</td>\n",
              "      <td>15814800</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2007-01-09</th>\n",
              "      <td>19.450001</td>\n",
              "      <td>19.709999</td>\n",
              "      <td>19.370001</td>\n",
              "      <td>19.650000</td>\n",
              "      <td>19.650000</td>\n",
              "      <td>14494200</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 2,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Single Feature"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.columns[4]"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 3,
          "data": {
            "text/plain": [
              "'Adj Close'"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 3,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.columns[0:3]"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 4,
          "data": {
            "text/plain": [
              "Index(['Open', 'High', 'Low'], dtype='object')"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 4,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X = dataset.iloc[ : , 1].values\n",
        "Y = dataset.iloc[ : , 4].values"
      ],
      "outputs": [],
      "execution_count": 5,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(X.shape)\n",
        "print(Y.shape)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2934,)\n",
            "(2934,)\n"
          ]
        }
      ],
      "execution_count": 6,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X = np.array(X).reshape(2934,-1)\n",
        "Y = np.array(Y).reshape(2934,-1)"
      ],
      "outputs": [],
      "execution_count": 7,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# from sklearn.cross_validation import train_test_split\n",
        "from sklearn.model_selection import train_test_split\n",
        "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 1/4, random_state = 0) "
      ],
      "outputs": [],
      "execution_count": 8,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 2: Fitting Simple Linear Regression Model to the training set"
      ],
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "Take data points from the dataset and convert it to training points. Then use training points to fit in the model."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.linear_model import LinearRegression\n",
        "regressor = LinearRegression()\n",
        "regressor = regressor.fit(X_train, Y_train)"
      ],
      "outputs": [],
      "execution_count": 9,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 3: Predicting the Result"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "Y_pred = regressor.predict(X_test)"
      ],
      "outputs": [],
      "execution_count": 10,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(X_train.shape)\n",
        "print(Y_train.shape)\n",
        "print(X_test.shape)\n",
        "print(Y_test.shape)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2200, 1)\n",
            "(2200, 1)\n",
            "(734, 1)\n",
            "(734, 1)\n"
          ]
        }
      ],
      "execution_count": 11,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Step 4: Visualization"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualising the Training results\n",
        "plt.scatter(X_train, Y_train, color = 'red')\n",
        "plt.plot(X_train, regressor.predict(X_train), color ='blue')"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 12,
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x1b512b8ff98>]"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<matplotlib.figure.Figure at 0x1b512897f28>"
            ],
            "image/png": [
              "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\n"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 12,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "regressor.score(X_train, Y_train)"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 13,
          "data": {
            "text/plain": [
              "0.99891156684540439"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 13,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualizing the test results\n",
        "plt.scatter(X_test, Y_test, color = 'red')\n",
        "plt.plot(X_test, regressor.predict(X_test), color ='blue')"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 14,
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x1b510649b00>]"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<matplotlib.figure.Figure at 0x1b512b61f28>"
            ],
            "image/png": [
              "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\n"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 14,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# score measure the proportion of correctly classified instances\n",
        "regressor.score(X_test, Y_test)"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 15,
          "data": {
            "text/plain": [
              "0.99857258481942379"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 15,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Simple Linear Regression (SLR) - Estimated Linear MOdel"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "# coefficient is a constant by which a variable is multiplied\n",
        "regressor.coef_"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 16,
          "data": {
            "text/plain": [
              "array([[ 0.98362718]])"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 16,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "regressor.intercept_"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 17,
          "data": {
            "text/plain": [
              "array([-0.02914215])"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 17,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Comparing Score\n",
        "print(\"X and Y:\", regressor.score(X, Y)) # This compares Y vs Y to give an accuracy measure because Y = predictor.predict(X). If calculate the raw data of X and Y; therefore, is okay.  \n",
        "print(\"X_train and Y_train:\",regressor.score(X_train, Y_train)) # This measure the accuracy of training data\n",
        "print(\"X_test and Y_test:\",regressor.score(X_test, Y_test)) # This measure the accuracy of test data and is similar to classification_report \n",
        "print(\"X_test and Y_test:\",regressor.score(X_test, Y_pred)) # This is not correct because it always give 1.0 and the library had calculated\n",
        "print(\"Y_test and Y_pred:\",regressor.score(Y_test, Y_pred)) # This accuracy of percentage is correct predictions"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X and Y: 0.998831288103\n",
            "X_train and Y_train: 0.998911566845\n",
            "X_test and Y_test: 0.998572584819\n",
            "X_test and Y_test: 1.0\n",
            "Y_test and Y_pred: 0.996908613047\n"
          ]
        }
      ],
      "execution_count": 18,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import statsmodels.api as sm\n",
        "\n",
        "# with statsmodels\n",
        "X = sm.add_constant(X) # adding a constant\n",
        " \n",
        "model = sm.OLS(Y, X).fit()\n",
        "predictions = model.predict(X) \n",
        " \n",
        "print_model = model.summary()\n",
        "print(print_model)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                            OLS Regression Results                            \n",
            "==============================================================================\n",
            "Dep. Variable:                      y   R-squared:                       0.999\n",
            "Model:                            OLS   Adj. R-squared:                  0.999\n",
            "Method:                 Least Squares   F-statistic:                 2.508e+06\n",
            "Date:                Sat, 08 Dec 2018   Prob (F-statistic):               0.00\n",
            "Time:                        18:07:32   Log-Likelihood:                 1571.7\n",
            "No. Observations:                2934   AIC:                            -3139.\n",
            "Df Residuals:                    2932   BIC:                            -3127.\n",
            "Df Model:                           1                                         \n",
            "Covariance Type:            nonrobust                                         \n",
            "==============================================================================\n",
            "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
            "------------------------------------------------------------------------------\n",
            "const         -0.0264      0.005     -5.219      0.000      -0.036      -0.016\n",
            "x1             0.9829      0.001   1583.522      0.000       0.982       0.984\n",
            "==============================================================================\n",
            "Omnibus:                     1830.969   Durbin-Watson:                   1.787\n",
            "Prob(Omnibus):                  0.000   Jarque-Bera (JB):            36842.601\n",
            "Skew:                          -2.603   Prob(JB):                         0.00\n",
            "Kurtosis:                      19.561   Cond. No.                         15.9\n",
            "==============================================================================\n",
            "\n",
            "Warnings:\n",
            "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n"
          ]
        }
      ],
      "execution_count": 19,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "LEAST SQUARES METHOD\n",
        "\nLeast Squares Method is the most common method for fitting a regression line. This method is used for to calculates the best-fitting line for the observed data by minimizing the sum of the squares of the vertical deviations from each data point to the line."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(12,8))\n",
        "plt.grid()\n",
        "plt.scatter(X_test, Y_test, color = 'red')\n",
        "plt.plot(X_test, regressor.predict(X_test), color ='blue')\n",
        "#plt.errorbar(X_test, Y_test, yerr=0.5, fmt='o', color='black',\n",
        "#             ecolor='lightgray', elinewidth=3, capsize=0);\n",
        "plt.ylabel(\"Dependent Variable\")\n",
        "plt.xlabel(\"Independent Variable\")\n",
        "plt.title(\"Least Squares Method\")"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 20,
          "data": {
            "text/plain": [
              "<matplotlib.text.Text at 0x1b513be4f98>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<matplotlib.figure.Figure at 0x1b51379a390>"
            ],
            "image/png": [
              "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\n"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 20,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from matplotlib import style\n",
        "style.use('dark_background')\n",
        "\n",
        "plt.title('Linear Regression')\n",
        "plt.scatter(X_test, Y_test,color='#5b9dff',label='data')\n",
        "plt.scatter(regressor.predict(X_test), regressor.predict(Y_test), color='#fc003f', label=\"predicted\")\n",
        "plt.plot(X_test,regressor.predict(X_test), color='000000', label='regression line')\n",
        "plt.legend(loc=4)"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 23,
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x1b513e13fd0>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<matplotlib.figure.Figure at 0x1b513dc79e8>"
            ],
            "image/png": [
              "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\n"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 23,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false
      }
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "pygments_lexer": "ipython3",
      "version": "3.5.5",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      },
      "nbconvert_exporter": "python",
      "name": "python"
    },
    "kernelspec": {
      "name": "python3",
      "language": "python",
      "display_name": "Python 3"
    },
    "nteract": {
      "version": "0.12.2"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}